'---------------------------------------------------
sub DoIfDef TheName$
	Du = IsDefined(TheName$)
	if Du <> 0 then
		' It's defined
		call Analyze
	else ' Gulp until we find "#else" or "#endif"
		do
			call GetNextLine
			Du$ = word$(RawData$,1)
			if Du$ = "#else" then
				call Analyze
				exit do
			end if
		loop until Du$ = "#endif"
	
	end if
end sub

Add the code, and test it out. You should now be able to #define a variable within a #if block, something you could not do previously.

File: BPREP-5.BAS

The next command will be "#include". To start this, we'll need to modify the initialization subroutine as well as the input and output subroutines and the error handler. We'll also need a test program or two. We'll start with the testers:

' File Test5-1.bas

FOR n = 1 TO 10
	PRINT "Who are you?"
NEXT n

There's no #include command yet -- we're just seeing how well we can read & write a single file.

' File: Test5-2.bas

PRINT "In Test1.mod"

Now, we'll change InitializeSystem by adding an OPEN command. File handles are naturally Global, so that saves a little work. We won't do any writes to a file yet -- we want to see where we're going.

'---------------------------------------------------
sub InitializeSystem
	FILEDIALOG "File to Process", "*.*", FilePath$
	InHandle$ = "1"
	open FilePath$ for input as #InHandle$
	' Get the File Path
	for n = len(FilePath$) to 1 step -1
		Du$ = mid$(FilePath$,n,1)
		if Du$ = "\" then
			Path$ = left$(FilePath$,n)
			exit for
		end if
	next n
    call write "' BASIC Preprocessor"
    call write "'"
end sub

'---------------------------------------------------
sub DoError ErrMsg$
	call write ErrMsg$
	close #InHandle$
	input A$
	end
end sub

'+++

We'll have to modify GetNextLine to read from files. So far, we're just opening and closing one file, so we don't need to get too fancy; however, note that I'm changing GetNextLine from a SUB to a FUNCTION, to flag when we've hit the end of the file.

'---------------------------------------------------
function GetNextLine()
' Eats up blank lines
    do
[CheckEOF]	
		if eof(#InHandle$) <> 0 then
			if FHAIndex > 0 then
				close #InHandle$
				InHandle$ = FileHandleArray$(FHAIndex)
				FHAIndex = FHAIndex - 1
				goto [CheckEOF]
			else ' FHAIndex
				close #InHandle$
				RawData$ = ""
				GetNextLine = FALSE
				exit do
			end if ' FHAIndex
		end if ' eof

		line input #InHandle$, RawData$
			
		Du = instr(RawData$, COMMENT$)
		if Du <> 0 Then
			RawData$ = left$(RawData$,Du-1)
		end if
		RawData$ = RTrim$(RawData$)
		GetNextLine = TRUE
	loop while RawData$ = ""
end function

Run the code. You should see the File Dialog come up. Select "TEST.BAS", and you'll see the contents of TEST1.BAS getting printed on the console. Now, we'll need to add the "include" command to Analyze, and a subroutine for it, along with a function to test if the file exists.

'---------------------------------------------------
sub DoInclude TheFileName$
	Du = instr(TheFileName$,chr$(34))
	
	' Test for quotes
	if Du = 0 then 
		call DoError "Include filenames must have "+chr$(34)+"s"
	end if
	File$ = mid$(TheFileName$,Du+1)
	Du = instr(File$,chr$(34))
	
	' Test for quotes
	if Du = 0 then 
		call DoError "Include filenames must have "+chr$(34)+"s"
	end if
	File$ = left$(File$,Du-1)

	if File$ = "" then
		call DoError "Include must have a filename."
	else
		' Load InHandle$ into next entry of array
		FHAIndex = FHAIndex + 1
		if FHAIndex > MAXFILES then
			call DoError "Maximum number of open files exceeded."
		end if
		FileHandleArray$(FHAIndex) = InHandle$
		' Iniz file handle
		InHandle$ = "1"
		' Add current path if none is shown
		if instr(File$,"/") = 0 then
			FilePath$ = Path$+File$
		end if
		' Open the file
		if FileExists(File$) then
			open FilePath$ for input as #InHandle$
		else
			call DoError File$+" does not exist in "+Path$
		end if
	end if
end sub

'---------------------------------------------------
function FileExists(File$)
	files Path$, File$, FileInfo$()
	FileExists = val(FileInfo$(0, 0))  'non zero is true
end function

Note that there is a lot of testing going on in the function. I'd rather have the software tell me why it failed rather than the OS error message, which is usually less than helpful! Also, I've limited the maximum number of files that can be open simultaneously to 10, which should be more than enough. If not, just change MAXFILES.

File: BPREP-6.BAS

We'll wind this up with modifying the way the outputs are written. Up to this point, all output has gone to the main window. This is OK for testing, but for serious work we need to put the preprocessor output to a file, and use some popup windows for the error messages.

First, we'll turn off the main window, and add a global name for the output handle. Call it "OutHandle"!

NOMAINWIN
'====== GLOBALS =======
global TRUE, FALSE, TRUE$, FALSE$
global COMMENT$, TAB$

FALSE = 0
TRUE = -1
FALSE$ = "0"
TRUE$ = "-1"
COMMENT$ = "'"
TAB$ = CHR$(9)

global RawData$

' Definitions
global MAXDEFS, Definition$, NextDef
MAXDEFS = 1000
DIM Definition$(MAXDEFS)
NextDef = 1

' Include
' Most files open at one time
global MAXFILES
' Working file handle
global InHandle$
' Fully-qualified file name
global FilePath$
' Path (from FilePath$)
global Path$

MAXFILES = 10
' Holds open handles
DIM FileHandleArray$(MAXFILES)
' Points to current FileHandleArray$ entry
global FHAIndex
FHAIndex = 0
' Used to see if file exists
dim FileInfo$(10, 10)

Then we'll need to add a FILEDIALOG to InitializeSystem to get the output file name, and close the handle in GetNextLine().

'---------------------------------------------------
sub InitializeSystem
	FILEDIALOG "File to Process", "*.*", FilePath$
	InHandle$ = "1"
	open FilePath$ for input as #InHandle$
	' Get the File Path
	for n = len(FilePath$) to 1 step -1
		Du$ = mid$(FilePath$,n,1)
		if Du$ = "\" then
			Path$ = left$(FilePath$,n)
			exit for
		end if
	next n

	FILEDIALOG "File to Write to", "*.*", OFilePath$
	open OFilePath$ for output as #OutHandle

    call write "' BASIC Preprocessor"
    call write "'"
end sub

'---------------------------------------------------
function GetNextLine()
' Eats up blank lines
    do
[CheckEOF]	
		if eof(#InHandle$) <> 0 then
			if FHAIndex > 0 then
				close #InHandle$
				InHandle$ = FileHandleArray$(FHAIndex)
				FHAIndex = FHAIndex - 1
				goto [CheckEOF]
			else ' FHAIndex
				close #InHandle$
				close #OutHandle
				RawData$ = ""
				GetNextLine = FALSE
				exit do
			end if ' FHAIndex
		end if ' eof

		line input #InHandle$, RawData$
			
		Du = instr(RawData$, COMMENT$)
		if Du <> 0 Then
			RawData$ = left$(RawData$,Du-1)
		end if
		RawData$ = RTrim$(RawData$)
		GetNextLine = TRUE
	loop while RawData$ = ""
end function

"write" will need to be changed to send output to the output file handle:

'---------------------------------------------------
sub write aString$
    print #OutHandle, aString$
end sub

'---------------------------------------------------
sub Analyze
	if GetNextLine() = TRUE then ' Loads RawData$
		do		
			if instr(RawData$,"#") <> 0 then
				' Trim any leading spaces
				PPCmdStr$ = trim$(RawData$)
				' make sure the # is first in the line
				if left$(PPCmdStr$,1) = "#" then
					' Get the command
					PPCmd$ = word$(PPCmdStr$,1)
					' Trim it
					PPCmdStr$ = trim$(mid$(PPCmdStr$,len(PPCmd$)+1))
					select case PPCmd$
						case "#define"					
							call DoDefine PPCmdStr$
						case "#undefine"					
							call DoUndefine PPCmdStr$
						case "#ifdef"
							call DoIfDef PPCmdStr$
						case "#else"
							call DoElse
                            exit do ' Get out of the #IFDEF Analyze
						case "#endif"
							call DoEndIf
                            exit do ' Get out of the #IFDEF Analyze
						case "#include"
							call DoInclude PPCmdStr$
					end select
				end if
			else
				call write RawData$
			end if
		loop while GetNextLine() = TRUE
	end if
end sub

'---------------------------------------------------
sub DoError ErrMsg$
	notice "Fatal Error!" + chr$(13) + ErrMsg$
	close #InHandle$
	close #OutHandle
	end
end sub

'+++

	notice "Preprocessing is Complete."
end